/**
 * kl yy-ds @2021
 */
package com.cxps.server.type.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cxps.cloud.base.MyTree;
import com.cxps.cloud.enums.DataStatus;
import com.cxps.cloud.utils.IdUtils;
import com.cxps.server.feign.Feign2es;
import com.cxps.server.type.domain.ProductType;
import com.cxps.server.type.domain.ProductTypeQuery;
import com.cxps.server.type.mapper.ProductTypeMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * 商品类型 业务逻辑层
 *
 * @author YouCai.Liu
 * @since 2021/11/1
 * ...
 */
@Service
public class ProductTypeService {

    @Autowired
    private ProductTypeMapper productTypeMapper;

    @Resource
    private Feign2es feign2es;

    /**
     * 商品分类
     *
     * @return
     */
    public Page list(ProductTypeQuery query) {

        Page<ProductType> page = new Page<>(query.getCurrent(), query.getSize());

        QueryWrapper<ProductType> qw = new QueryWrapper<>();
        qw.eq("status", DataStatus.ON_LINE.getCode());

        return productTypeMapper.selectPage(page, qw);
    }

    /**
     * 商品分类添加
     *
     * @param productType
     * @return
     */
    public void add(ProductType productType) {
        if (StringUtils.isBlank(productType.getPid())) {
            productType.setPid("-1");
        }
        productType.setStatus(DataStatus.ON_LINE.getCode());
        if (StringUtils.isBlank(productType.getId())) {
            productType.setId(IdUtils.generateId());
            productTypeMapper.insert(productType);
        } else {
            productTypeMapper.updateById(productType);
        }
    }

    /**
     * 更新缓存
     */
    public void updateCache() {
        feign2es.cacheProductType();
    }


    /**
     * 商品分类修改
     *
     * @param productType
     */
    public void update(ProductType productType) {
        if (StringUtils.isBlank(productType.getPid())) {
            productType.setPid("-1");
        }
        productType.setStatus(DataStatus.ON_LINE.getCode());
        productTypeMapper.updateById(productType);

        // 更新缓存
        feign2es.cacheProductType();
    }

    /**
     * 根据ID查询商品分类
     *
     * @param id
     * @return
     */
    public ProductType get(String id) {
        return productTypeMapper.selectById(id);
    }

    /**
     * 根据ID删除商品分类
     *
     * @param id
     * @return
     */
    public void del(String id) {
        // 查询当前删除的分类ID是否有子分类
        QueryWrapper<ProductType> qw = new QueryWrapper<>();
        qw.eq("pid", id);
        List<ProductType> typeList = productTypeMapper.selectList(qw);
        // 如果有子分类，则将所有分类ID放在ids集合全部删除
        List<String> ids = new ArrayList<>();
        if (null != typeList && !typeList.isEmpty()) {
            for (ProductType productType : typeList) {
                ids.add(productType.getId());
            }
        }
        ids.add(id);

        // 根据商品分类ID查询商品，存在商品不允许删除
        Long count = productTypeMapper.selectProductByProductId(ids);
        if (count > 0) {
            throw new IllegalArgumentException("商品类型正在使用，禁止删除");
        }

        // 删除商品分类
        productTypeMapper.deleteBatchIds(ids);

        // 更新缓存
        feign2es.cacheProductType();
    }

    /**
     * 商品分类树形数据
     *
     * @return
     */
    public List<MyTree> typeTree() {

        // 查询所有类型数据
        QueryWrapper<ProductType> qw = new QueryWrapper<>();
        qw.eq("status", DataStatus.ON_LINE.getCode());
        List<ProductType> typeList = productTypeMapper.selectList(qw);
        if (null == typeList || typeList.isEmpty()) {
            return null;
        }

        // 转成树形结构对象
        List<MyTree> myTreeList = new ArrayList<>();
        // 得到顶级分类
        List<MyTree> parentList = new ArrayList<>();
        for (ProductType entity : typeList) {
            MyTree myTree = new MyTree(entity.getId(), entity.getPid(), entity.getProductType(), entity.getId());
            myTreeList.add(myTree);
            // -1是顶级分类
            if ("-1".equals(entity.getPid())) {
                parentList.add(myTree);
            }
        }

        List<MyTree> result = new ArrayList<>();

        // 遍历顶级分类集合，递归查找子节点数据
        for (MyTree parent : parentList) {
            result.add(buildTree(parent, myTreeList));
        }

        return result;
    }

    /**
     * 递归构建树形结构数据
     *
     * @param parent  父节点数据
     * @param allList 所有数据
     * @return
     */
    private MyTree buildTree(MyTree parent, List<MyTree> allList) {

        // 父节点子数据
        List<MyTree> children = new ArrayList<>();

        // 遍历所有的菜单数据，如果当前的数据PID = 父节点数据的ID，则是子节点
        for (MyTree myTree : allList) {
            // 当前节点数据PID = 父节点数据的ID
            if (myTree.getPid().equals(parent.getId())) {
                children.add(myTree);
                // 调自己，继续往下找
                buildTree(myTree, allList);
            }
        }
        if (!children.isEmpty()) {
            parent.setChildren(children);
        }
        return parent;
    }
}
